home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2001 September / PC-WELT 9-2001.ISO / software / hw / brennen / flask_src.exe / Audio / Audio.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-26  |  23.6 KB  |  922 lines
  1. /* 
  2.  *  Audio.cpp 
  3.  *
  4.  *    Copyright (C) Alberto Vigata - January 2000 - ultraflask@yahoo.com
  5.  *
  6.  *  This file is part of FlasKMPEG, a free MPEG to MPEG/AVI converter
  7.  *    
  8.  *  FlasKMPEG is free software; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation; either version 2, or (at your option)
  11.  *  any later version.
  12.  *   
  13.  *  FlasKMPEG is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *   
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with GNU Make; see the file COPYING.  If not, write to
  20.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  21.  *
  22.  */
  23.  
  24. #include <stdio.h>
  25. #include "Audio.h"
  26. #include ".\AC3\CAC3Dec.h"
  27.  
  28.  
  29.  
  30. char *sAC3SampleFreq[4]={"48 Khz","44.1 Khz", "32 Khz","Unexpected"};
  31. int    AC3Acmod[]={ 2, 1, 2, 3, 3, 4, 4, 5 };
  32. int    AC3SampleFreq[4]={48000,44100,32000,0};
  33.  
  34. struct TFrameSize framesize_table[] = {
  35.       { 32  ,{64   ,69   ,96   } },
  36.       { 32  ,{64   ,70   ,96   } },
  37.       { 40  ,{80   ,87   ,120  } },
  38.       { 40  ,{80   ,88   ,120  } },
  39.       { 48  ,{96   ,104  ,144  } },
  40.       { 48  ,{96   ,105  ,144  } },
  41.       { 56  ,{112  ,121  ,168  } },
  42.       { 56  ,{112  ,122  ,168  } },
  43.       { 64  ,{128  ,139  ,192  } },
  44.       { 64  ,{128  ,140  ,192  } },
  45.       { 80  ,{160  ,174  ,240  } },
  46.       { 80  ,{160  ,175  ,240  } },
  47.       { 96  ,{192  ,208  ,288  } },
  48.       { 96  ,{192  ,209  ,288  } },
  49.       { 112 ,{224  ,243  ,336  } },
  50.       { 112 ,{224  ,244  ,336  } },
  51.       { 128 ,{256  ,278  ,384  } },
  52.       { 128 ,{256  ,279  ,384  } },
  53.       { 160 ,{320  ,348  ,480  } },
  54.       { 160 ,{320  ,349  ,480  } },
  55.       { 192 ,{384  ,417  ,576  } },
  56.       { 192 ,{384  ,418  ,576  } },
  57.       { 224 ,{448  ,487  ,672  } },
  58.       { 224 ,{448  ,488  ,672  } },
  59.       { 256 ,{512  ,557  ,768  } },
  60.       { 256 ,{512  ,558  ,768  } },
  61.       { 320 ,{640  ,696  ,960  } },
  62.       { 320 ,{640  ,697  ,960  } },
  63.       { 384 ,{768  ,835  ,1152 } },
  64.       { 384 ,{768  ,836  ,1152 } },
  65.       { 448 ,{896  ,975  ,1344 } },
  66.       { 448 ,{896  ,976  ,1344 } },
  67.       { 512 ,{1024 ,1114 ,1536 } },
  68.       { 512 ,{1024 ,1115 ,1536 } },
  69.       { 576 ,{1152 ,1253 ,1728 } },
  70.       { 576 ,{1152 ,1254 ,1728 } },
  71.       { 640 ,{1280 ,1393 ,1920 } },
  72.       { 640 ,{1280 ,1394 ,1920 } }};
  73.  
  74. static const int mpeg1_bitrate_table[3][15] = {
  75.     { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },
  76.     { 0, 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384 },
  77.     { 0, 32, 40, 48,  56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320 }
  78. };
  79.  
  80. static const int mpeg1_sampling_frequency[4] = { 44100, 48000, 32000 , 0 };
  81.  
  82. static const int mpeg2_bitrate_table[3][15] = {
  83.     {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, },
  84.     {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, },
  85.     {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, },
  86. };
  87.  
  88. //////////////////////////////////////////////////////////////////////
  89. // Construction/Destruction
  90. //////////////////////////////////////////////////////////////////////
  91.  
  92. Audio::Audio(char *inputFile, int streamID, int subStreamID, int mode):CDemux()
  93. {
  94.     
  95.     SetInput(inputFile);
  96.  
  97.     Audio::streamID     = streamID;
  98.     Audio::subStreamID  = subStreamID;
  99.  
  100.     resampler                    =  NULL;
  101.     decoded_samples_buffer       =  NULL;
  102.     ResamplerBuffer              =  NULL;
  103.     frameFIFO                    =  NULL;
  104.  
  105.  
  106.     Audio::sysClock=0;
  107.     //file opened
  108.     inp->SeekStream(0);
  109.  
  110.     //Detect Stream Type
  111.     /*    while ( (b->Show_Bits(16)!=AC3_SYNC_WORD) && (b->Show_Bits(12)!=MPEG_SYNC_WORD) )
  112.         b->Flush_Buffer(1); */
  113.     // Although this megamatic algorithm detectionroutines work in most cases
  114.     // some startcode emulation cases have been found
  115.     // for the time being, use stream_id as audio identifier
  116.     if( subStreamID>= 0x80 && subStreamID <= 0x87 ){
  117.         isAC3=true;
  118.         isMPEG=false;
  119.     }
  120.     else if ((streamID >= 0xC0) && (streamID <= 0xDF)){
  121.         isAC3=false;
  122.         isMPEG=true;
  123.     }
  124.     else{
  125.         isAC3=false;
  126.         isMPEG=false;
  127.     }
  128.     GetAudioProperties();
  129. }
  130.  
  131. Audio::~Audio()
  132. {
  133. }
  134.  
  135. int Audio::GetAudioProperties()
  136. {
  137.     TTimeSpan span;
  138.     span.start=0;
  139.     span.end = 0;
  140.     ui8 *data;
  141.     ui8 fscod, frmsizecode, acmod;
  142.  
  143.     // Create frame FIFO
  144.     frameFIFO = new CAudFrameBuffer();
  145.     ReadSpanInit();
  146.  
  147.     if(isAC3){
  148.         while(ReadSpan(&span, 1*MPEG2_CLK_REF) ){
  149.             if(frameFIFO->firstFrame==NULL)
  150.                 continue;
  151.             else{
  152.                 //Take the first frame to retrieve audio info
  153.                 data = frameFIFO->firstFrame->data;
  154.                 fscod       = (data[4] & 0xC0) >> 6;
  155.                 frmsizecode = (data[4] & 0x3F);
  156.  
  157.                 sampleRate = AC3SampleFreq[fscod];
  158.                 strcpy(sSampleRate, sAC3SampleFreq[fscod]);
  159.  
  160.                 sprintf(sBitRate,"%d Kbps", framesize_table[frmsizecode].bit_rate);
  161.  
  162.                 //Update channels info
  163.                 acmod = (data[6] & 0xE0) >> 5;
  164.                 sprintf(sAudioMode,"%d Channels ", AC3Acmod[acmod]);
  165.                 break;
  166.             }
  167.         }
  168.     }
  169.     if(isMPEG){
  170.         while(ReadSpan(&span, 1*MPEG2_CLK_REF) ){
  171.             if(frameFIFO->firstFrame==NULL)
  172.                 continue;
  173.             else{
  174.                 data = frameFIFO->firstFrame->data;
  175.                 long hdr;
  176.                 // Yay!  A valid MPEG header!  Parse it!
  177.  
  178.                 // 0000F0FF 12 bits    sync mark
  179.                 //
  180.                 // 00000800  1 bit    version
  181.                 // 00000600  2 bits    layer (3 = layer I, 2 = layer II, 1 = layer III)
  182.                 // 00000100  1 bit    error protection (0 = enabled)
  183.                 //
  184.                 // 00F00000  4 bits    bitrate_index
  185.                 // 000C0000  2 bits    sampling_freq
  186.                 // 00020000  1 bit    padding
  187.                 // 00010000  1 bit    extension
  188.                 //
  189.                 // C0000000  2 bits    mode (0=stereo, 1=joint stereo, 2=dual channel, 3=mono)
  190.                 // 30000000  2 bits    mode_ext
  191.                 // 08000000  1 bit    copyright
  192.                 // 04000000  1 bit    original
  193.                 // 03000000  2 bits    emphasis
  194.                 int is_mpeg2, layer, is_errorprotected, br_index, bitrate, sr_index, frequency;
  195.  
  196.                 memcpy(&hdr, data, 4);
  197.                 //hdr = ((hdr&0xFF000000)>>24) | ((hdr&0x00FF0000)>>8) |
  198.                 //      ((hdr&0x0000FF00)<< 8) | ((hdr&0x000000FF)<<24);
  199.  
  200.                 is_mpeg2            = !(hdr & 0x00000800);
  201.                 layer                = 4 - (hdr>>9)&3;
  202.                 is_errorprotected    = !(hdr & 0x00000100);
  203.                 br_index            = (hdr>>20)&15;
  204.                 bitrate                = (is_mpeg2 ? mpeg2_bitrate_table : mpeg1_bitrate_table)[layer-1][br_index];
  205.                 sr_index            = (hdr>>18)&3;
  206.                 frequency            = mpeg1_sampling_frequency[sr_index];
  207.  
  208.                 if (is_mpeg2)
  209.                     frequency>>=1;
  210.  
  211.                 sampleRate = frequency;
  212.  
  213.                 break;
  214.             }
  215.         }
  216.     }
  217.     delete frameFIFO;
  218.     return 1;
  219. }
  220.  
  221. //DO_AUDIO start
  222. int Audio::Start(int out_sFreq, i64 PTS, int audioMode){
  223.     Audio::audioMode=audioMode;
  224.  
  225.  
  226.     //AC.CreateCompressor();
  227.  
  228.     resampler=NULL;
  229.     decoded_samples_buffer=NULL;
  230.     ResamplerBuffer=NULL;
  231.     frameFIFO  =NULL;
  232.     // read init
  233.     frame_in_progress = false;
  234.     aud_clk           = 0;
  235.     tot_n_samples     = 0;
  236.     StartReadLPES();
  237.  
  238.     if(audioMode==DO_AUDIO){
  239.         ReadSpanInit();
  240.         startPTS=PTS;
  241.         justStarted=true;
  242.         zeroSamplesToPad=0;
  243.         PCM_PTS=PTS;
  244.         sampleTime= (double)MPEG2_CLK_REF/((double)sampleRate);
  245.  
  246.         if(isAC3){
  247.             AC3Dec  = new CAC3Dec;
  248.             AC3Dec->Init();
  249.         }
  250.         if(isMPEG){
  251.  
  252.             MPEGDec = new CMPEGDec;
  253.             MPEGDec->Start();
  254.         }
  255.  
  256.         frameFIFO = new CAudFrameBuffer();
  257.         //Resampling stuff 
  258.         if(out_sFreq!=sampleRate){
  259.             double factor= (double)out_sFreq/(double)sampleRate;
  260.             decoded_samples_buffer= new CAsyncBuffer(this, PCM_1SECOND_SIZE, 1);
  261.             resampler= new CResampler(factor, 2/*stereo*/,(CAsyncBuffer *)decoded_samples_buffer);
  262.             resampler->ResampleFastStart();
  263.             ResamplerBuffer= new CAsyncBuffer(resampler, 4096, 10);
  264.             doResampling=true;
  265.         }
  266.         else{
  267.             decoded_samples_buffer= new CAsyncBuffer((CDataSource *)this, PCM_1SECOND_SIZE,1);
  268.             doResampling=false;
  269.         }
  270.         return 1;
  271.     }
  272.     return 0;
  273. }
  274. //DSC start
  275. int Audio::Start(char *inputFileName, int audioMode)
  276. {    
  277.     StartReadLPES();
  278.     //eos
  279.     resampler=NULL;
  280.     decoded_samples_buffer=NULL;
  281.     ResamplerBuffer=NULL;
  282.     frameFIFO=NULL;
  283.     
  284.     frameFIFO = new CAudFrameBuffer();
  285.     ReadSpanInit();
  286.     char szTemp[1024];
  287.     Audio::audioMode=audioMode;
  288.     if(audioMode==DSC){
  289.         justStarted=true;
  290.         if(isAC3){
  291.  
  292.             strcpy(szTemp, inputFileName);
  293.             strcat(szTemp, ".AC3");
  294.             if((hOutputFile=fopen(szTemp,"wb"))==NULL)
  295.                 return 0;
  296.         }
  297.         else if(isMPEG){
  298.             strcpy(szTemp, inputFileName);
  299.             strcat(szTemp, ".mp2");
  300.             if((hOutputFile=fopen(szTemp,"wb"))==NULL)
  301.                 return 0;
  302.         }
  303.         else
  304.             return 0;
  305.         //AlignFrame();
  306.         justStarted=true;
  307.         firstPTSfound=false;
  308.     }
  309.  
  310.  
  311.     return 1;
  312. }
  313.  
  314. int Audio::Stop()
  315. {
  316.     stopDecoder=true;
  317.     justStarted=false;
  318.  
  319.     if(audioMode==DSC){
  320.         //EndWritingFrame();
  321.         //close file
  322.         fclose(hOutputFile);
  323.     }
  324.     else if(audioMode==DO_AUDIO)
  325.     {
  326.         if(resampler){
  327.             resampler->ResampleFastStop();
  328.             delete resampler;
  329.             resampler=NULL;
  330.         }
  331.         if(decoded_samples_buffer){
  332.             delete decoded_samples_buffer;
  333.             decoded_samples_buffer=NULL;
  334.         }
  335.         if(ResamplerBuffer){
  336.             delete ResamplerBuffer;
  337.             ResamplerBuffer=NULL;
  338.         }
  339.         if(isAC3)
  340.             if(AC3Dec){
  341.                 delete AC3Dec;
  342.                 AC3Dec=NULL;
  343.             }
  344.         if(isMPEG)
  345.             if(isMPEG){
  346.                 delete MPEGDec;
  347.                 MPEGDec=NULL;
  348.             }
  349.     }
  350.     if(audioMode == DSC || audioMode==DO_AUDIO )
  351.         if(frameFIFO){
  352.             delete frameFIFO;
  353.             frameFIFO=NULL;
  354.         }    
  355.     return 1;
  356. }
  357. /*
  358. int Audio::GetAudio()
  359. {
  360.     int bytesRead;
  361.     if( (bytesRead=ReadStream( buffer, AUDIO_BUFFER_SIZE)) == AUDIO_BUFFER_SIZE){
  362.         fwrite( buffer, 1, bytesRead, hOutputFile); 
  363.         return 1;
  364.     }
  365.     else{
  366.             fwrite( buffer, 1, bytesRead, hOutputFile); 
  367.             goto end;
  368.     }
  369.  
  370. end:
  371. //    decoderStopped=true;
  372.     return 0;
  373.  
  374. }
  375. */
  376.  
  377. int Audio::SeekPTS(i64 PTS, i64 searchTop)
  378. {
  379.     //We have to align the first frame with PTS greater or equal
  380.     // to the given PTS, until searchTop byte of input stream
  381.     //If the search was unsuccesful, return 0
  382.     // return 1 otherwise
  383.  
  384.     if(isAC3){
  385.     while(((b->Show_Bits(16)!=AC3_SYNC_WORD) || (b->PES.PTS<PTS)) && inp->GetStreamPos()<searchTop)
  386.         b->Flush_Buffer(1);
  387.     }
  388.     else if(isMPEG){
  389.     while(((b->Show_Bits(12)!=MPEG_SYNC_WORD) || (b->PES.PTS<PTS)) && inp->GetStreamPos()<searchTop)
  390.         b->Flush_Buffer(1);
  391.  
  392.     }
  393.     else return 0;
  394.  
  395.     if(inp->GetStreamPos()<searchTop) //Success
  396.     // We should be at the right packet now
  397.         return 1;
  398.     else 
  399.         return 0;
  400. }
  401.  
  402. int Audio::AlignFrame()
  403. {
  404.  
  405.     if(isAC3){
  406.     while(b->Show_Bits(16)!=AC3_SYNC_WORD)
  407.         b->Flush_Buffer(1);
  408.     }
  409.     else if(isMPEG){
  410.     while((b->Show_Bits(12)!=MPEG_SYNC_WORD))
  411.         b->Flush_Buffer(1);
  412.  
  413.     }
  414.     else return 0;
  415.  
  416.     // We should be at the right packet now
  417.     return 1;
  418. }
  419.  
  420. //GetAudio Direct Stream Copy
  421. int Audio::GetAudioDSC(i64 PTS, i64 videoStreamPos)
  422. {
  423.     TTimeSpan span;
  424.  
  425. /*    if(justStarted || firstPTSfound==false){
  426.         if(justStarted)
  427.             firstPTS=PTS;
  428.         justStarted=false;
  429.  
  430.         if(!SeekPTS(firstPTS,videoStreamPos)){    //Align to the PTS with this PTS
  431.             firstPTSfound=false;
  432.             return 0;
  433.         }
  434.         else
  435.             firstPTSfound=true;
  436.         
  437.     }*/
  438.     //Parse packets up to videoStreamPos
  439.  
  440.     while(inp->GetStreamPos()<videoStreamPos){
  441.         ReadSpan(&span, MPEG2_CLK_REF);
  442.         while( frameFIFO->firstFrame ){
  443.             fwrite( frameFIFO->firstFrame->data, frameFIFO->firstFrame->datasize , 1, hOutputFile); 
  444.             frameFIFO->RemoveFrame( frameFIFO->firstFrame );
  445.         }
  446.     }
  447.  
  448.  
  449.         return 1;
  450.     
  451. }
  452.  
  453. int Audio::EndWritingFrame()
  454. {    int my_bits=0;
  455.     char buffer=0;
  456.     if(isAC3){
  457.         while((b->Show_Bits(16)!=AC3_SYNC_WORD) && b->eos==false ){
  458.  
  459.             buffer+= b->Get_Bits(1);
  460.             buffer=buffer<<1;
  461.             my_bits++;
  462.             if(my_bits>=8){
  463.                 fwrite( &buffer, sizeof(buffer) , 1, hOutputFile);
  464.                 my_bits=0;
  465.                 buffer=0;
  466.             }
  467.         }
  468.     }
  469.     return 1;
  470. }
  471.  
  472. int Audio::SeekAudio(i64 pos)
  473. {
  474.     int val;
  475.     val=inp->SetStreamPos(pos);
  476.  
  477.     return val;
  478. }
  479.  
  480. int Audio::GetSamples(int frame, short **buffer, int nSamples)
  481. {/*
  482.     if(justStarted){//Find first frame with PTS>PCM_PTS
  483.         while(b->PES.PTS<PCM_PTS){
  484.             b->Flush_Buffer(16); //Parse header
  485.             AlignFrame();
  486.         }
  487.         justStarted=false;
  488.     }
  489. */
  490.     if(doResampling)
  491.         ResamplerBuffer->ReadBuffer((char **)buffer, nSamples*4);
  492.     else
  493.         decoded_samples_buffer->ReadBuffer((char **)buffer, nSamples*4);
  494.  
  495.     //AC.Compress( *buffer, nSamples*2 );
  496.     return 0;
  497. }
  498.  
  499. #define ROUND(x) ( ((x-floor(x)) > 0.5) ? ceil(x) : floor(x) )
  500. int Audio::read(char *buffer){
  501.  
  502.     TTimeSpan span;
  503.     span.start=0;
  504.     span.end = 0;
  505.     
  506.     CAudioFrame  *frame, *nextframe = NULL;
  507.  
  508.     ReadSpan(&span, 1*MPEG2_CLK_REF);
  509.  
  510.     i32  diff,span_samples_offset =0;
  511.     ui32  frame_pcm_samples;
  512.     i32  span_ptr = 0;
  513.  
  514.     // Update local audio clock, number of samples for this span,
  515.     //      and total number of samples.
  516.     aud_clk        += span.end - span.start;
  517.     ui32 n_samples  = ROUND((double)(aud_clk*sampleRate)/(double)MPEG2_CLK_REF) - tot_n_samples;
  518.     tot_n_samples  += n_samples;
  519.  
  520.  
  521.     frame_pcm_samples = isAC3 ? 1536 : (isMPEG ? 1152 : 0) ;
  522.     ui32 frame_duration = ((double)frame_pcm_samples/(double)sampleRate) * (double)MPEG2_CLK_REF;
  523.  
  524.     short *samples = (short *)buffer;
  525.     memset(samples, 0, n_samples*4);
  526.  
  527.     OutputDebugString("span start");    
  528.     /*while( span_ptr < n_samples){*/
  529.     if(frame_in_progress){
  530.         memcpy( &samples[span_ptr*2], &temp_decoded_frame[temp_decoded_ptr*2], fip_remaining_bytes);
  531.         span_ptr += (fip_remaining_bytes>>2);
  532.         frame_in_progress = false;
  533.     }
  534.  
  535.     if(frameFIFO->firstFrame){
  536.         frame = frameFIFO->firstFrame;
  537.         while( span_ptr < n_samples )
  538.         {
  539.             // we update nextframe here because it's likely to remove the
  540.             // present frame during this iteration
  541.             nextframe = frame->next;
  542.             // If the frame doesn't fit in this span
  543.             if( (span_ptr + frame_pcm_samples ) > n_samples){
  544.                 frame_in_progress=true;
  545.                 decodeFrame( frame, temp_decoded_frame);
  546.                 temp_decoded_ptr = n_samples - span_ptr;
  547.                 memcpy( &samples[span_ptr*2], temp_decoded_frame, temp_decoded_ptr*4);
  548.                 
  549.                 fip_remaining_bytes = (frame_pcm_samples*4) - (temp_decoded_ptr*4);
  550.                 frameFIFO->RemoveFrame(frame);
  551.                 span_ptr += temp_decoded_ptr;
  552.                 goto end;
  553.             }
  554.             if(frame->pInfo.hasPTS)
  555.             {    
  556.                 if( (frame->pInfo.PTS >= span.start) ){
  557.                     if(frame->pInfo.PTS > span.end)
  558.                         //frame out of the span
  559.                         goto end;
  560.                     // The frame starts inside this span
  561. /*                    if( (span.end - frame->pInfo.PTS) < frame_duration ){
  562.                         if(frame_in_progress){ //Oddly there is already a frame in progress. Remove it
  563.                             frameFIFO->RemoveFrame(frame);
  564.                             goto end;
  565.                         }
  566.                         //The frame doesn't completely fit into this span
  567.                         frame_in_progress=true;
  568.                         
  569.                         decodeFrame(frame, temp_decoded_frame);
  570.  
  571.                         temp_decoded_ptr = n_samples - span_ptr;
  572.                         memcpy( &samples[span_ptr*2], temp_decoded_frame, temp_decoded_ptr*4);
  573.     
  574.                         fip_remaining_bytes = (frame_pcm_samples*4) - (temp_decoded_ptr*4);
  575.                         frameFIFO->RemoveFrame(frame);
  576.                         span_ptr += temp_decoded_ptr;
  577.         
  578.                     }
  579.                     else{*/
  580.                         span_samples_offset = ROUND((double)((frame->pInfo.PTS - span.start)*sampleRate)/(double)MPEG2_CLK_REF);
  581.                         /*if(span_samples_offset < span_ptr){
  582.                             //Something went wrong with this PTS. Put this frame
  583.                             // behind the decoded data if there is room for it
  584.                             if( (span_ptr+1536) <= n_samples ){
  585.                                 AC3Dec->decodeFrame((short *)frame->data, &samples[span_ptr*2]);
  586.                                 frameFIFO->RemoveFrame(frame);
  587.                                 span_ptr+= 1536;
  588.                             }
  589.                             goto end;
  590.                         }*/
  591.                         //Handle small clock jitter
  592.                         diff=span_samples_offset-span_ptr;
  593.                         if( diff < 0 )
  594.                             span_samples_offset = span_ptr;
  595.                         else{
  596.                             diff = (diff>0) ? diff : -diff;
  597.                             if( diff < CLK_THRESHOLD )
  598.                                 span_samples_offset = span_ptr;
  599.                         }
  600.  
  601.                         decodeFrame(frame, &samples[span_samples_offset*2]);
  602.  
  603.                         span_ptr = span_samples_offset + frame_pcm_samples;
  604.                         frameFIFO->RemoveFrame(frame);
  605.                     /*}*/
  606.                 }
  607.                 else{ 
  608.                     //The frame has a PTS previous to this span. ┐┐??
  609.                     //HACK
  610.                     // Decode the frame if the PTS from the current time
  611.                     //    is just a little bit behind
  612.                     int clk_span = ((double)span_ptr/(double)sampleRate) * (double)MPEG2_CLK_REF;
  613.                     if( ((span.start+clk_span) - frame->pInfo.PTS)  < CLK_THRESHOLD_SPAN){
  614.                         decodeFrame( frame, &samples[span_ptr*2] );
  615.                         span_ptr += frame_pcm_samples;
  616.                     }
  617.                     frameFIFO->RemoveFrame(frame);
  618.                 }
  619.  
  620.             }
  621.             else{
  622.                     // decode frame right away
  623.                     decodeFrame( frame, &samples[span_ptr*2] );
  624.                     span_ptr += frame_pcm_samples;
  625.                     frameFIFO->RemoveFrame(frame);
  626.             }
  627.  
  628. end:
  629.         if( nextframe==NULL )
  630.             break;
  631.         else
  632.             frame = nextframe;
  633.       }
  634.     }
  635.     //else There are no frames to be decoded in this span
  636.     OutputDebugString("Audio Span End\n");
  637. /*    }*/
  638.     return n_samples*4;
  639. }
  640.  
  641.  
  642.  
  643. int Audio::ReadSpan(TTimeSpan *span, i64 time)
  644. {
  645.     ui64  nextSCR;
  646.     int   not_eof;
  647.  
  648.     not_eof=1;
  649.     span->start = read_state.lastSCR;
  650.     span->end   = span->start;
  651.     while( ((span->end - span->start) < time) && not_eof)
  652.     {
  653.         if(    streamID==read_state.PES.pInfo.streamID && 
  654.             subStreamID==read_state.PES.pInfo.subStreamID )
  655.                 ParseFrameData();
  656.  
  657.         not_eof=ReadLPES((unsigned char **)&read_state.PES.data, &read_state.PES.pInfo);
  658.         if(!not_eof)
  659.             break;
  660.  
  661.         span->end   = read_state.PES.pInfo.SCR;
  662.  
  663.         // Update variables for next loop
  664.         read_state.lastSCR       = read_state.PES.pInfo.SCR;
  665.     }
  666.     return not_eof;
  667. }
  668.  
  669. int inline Audio::RetrieveFrameData()
  670. {
  671.         ui32 PES_bytes_left  = read_state.PES.pInfo.payloadSize - read_state.in_ptr;
  672.         ui8 *optr            = &read_state.frame_data[read_state.out_ptr];
  673.         ui8 *iptr            = read_state.PES.data + read_state.in_ptr;
  674.  
  675.         if(read_state.frame_remaining_bytes <= PES_bytes_left){
  676.             memcpy(optr, iptr, read_state.frame_remaining_bytes);
  677.             // Add frame to the FIFO
  678.             frameFIFO->AddFrame( read_state.frame_data, 
  679.                                  read_state.frame_size,
  680.                                 &read_state.frame_pInfo);
  681.             read_state.frame_in_course = false;
  682.             read_state.in_ptr += read_state.frame_remaining_bytes;
  683.             return 1;
  684.         }
  685.         else{
  686.             memcpy(optr, iptr, PES_bytes_left);
  687.             read_state.frame_in_course = true;
  688.             read_state.out_ptr               += PES_bytes_left;
  689.             read_state.frame_remaining_bytes -= PES_bytes_left;
  690.             return 0;
  691.         }
  692. }
  693.  
  694. void inline Audio::ParseFrameData()
  695. {
  696.     ui8 *dataptr;
  697.     ui32 headers_found = 0;
  698.  
  699.     read_state.in_ptr = 0;
  700.  
  701.     // take any possible audio frame and put it in the audio frame FIFO
  702.     // we enter in this function when a PES of our ID was found
  703.  
  704.     // parse the frame in course
  705.     if(read_state.frame_in_course){
  706.         if(!RetrieveFrameData())
  707.             return;
  708.     }
  709.     // wh
  710.     while( read_state.in_ptr < read_state.PES.pInfo.payloadSize ){
  711.         if(FindHeader(headers_found)){
  712.             //An audio header was found
  713.             headers_found++;
  714.             if(!RetrieveFrameData())
  715.                 return;
  716.         }
  717.         else
  718.             break;
  719.     }
  720.     
  721. }
  722.  
  723.  
  724. int Audio::ParseHeader(ui32 headers_found)
  725. {
  726.  
  727.  
  728.     ui8  *data = read_state.PES.data;
  729.     ui8  fscod;
  730.     ui8  frmsizecode;
  731.  
  732.  
  733.  
  734.     if(isAC3){
  735.         if( data[read_state.in_ptr]==0x0B && header_pos==0){
  736.             read_state.header_in_course = true;
  737.             header_pos = 1;
  738.             //Handle presentation info
  739.             if(    (read_state.PES.pInfo.PTS != 0) 
  740.                 && (headers_found==0)  ){
  741.                     read_state.frame_pInfo.hasPTS = true;
  742.                     read_state.frame_pInfo.PTS    
  743.                     = read_state.PES.pInfo.PTS;
  744.                 }
  745.                 else{
  746.                     read_state.frame_pInfo.hasPTS = false;
  747.                     read_state.frame_pInfo.PTS    = 0;
  748.             }
  749.             return 0;
  750.         }
  751.  
  752.         if( data[read_state.in_ptr]==0x77 && header_pos==1){
  753.             read_state.header_in_course = true;
  754.             header_pos = 2;
  755.             return 0;
  756.         }
  757.         if( header_pos==2 ){
  758.             read_state.header_in_course = true;
  759.             hdr2 = data[read_state.in_ptr];
  760.             header_pos = 3;
  761.             return 0;
  762.         }
  763.         if( header_pos==3 ){
  764.             read_state.header_in_course = true;
  765.             hdr3 = data[read_state.in_ptr];
  766.             header_pos = 4;
  767.             return 0;
  768.         } 
  769.         if( header_pos==4 ){
  770.             read_state.header_in_course = true;
  771.                 fscod       = (data[read_state.in_ptr] & 0xC0) >> 6;
  772.                 frmsizecode = (data[read_state.in_ptr] & 0x3F);    
  773.  
  774.                 // Check fscod and frmsizecode for valid parameters
  775.                 if( (fscod!=3) && (frmsizecode<38) ){
  776.                     read_state.frame_size = framesize_table[frmsizecode].frm_size[fscod]*2;            
  777.     
  778.                     //Reconstruct frame header
  779.                     read_state.frame_data[0] = 0x0B;
  780.                     read_state.frame_data[1] = 0x77;
  781.                     read_state.frame_data[2] = hdr2;
  782.                     read_state.frame_data[3] = hdr3;
  783.                     read_state.frame_data[4] = data[read_state.in_ptr];
  784.                 
  785.  
  786.  
  787.                     read_state.frame_remaining_bytes = read_state.frame_size - 5;
  788.                     read_state.out_ptr               = 5;
  789.                     header_pos = 0;
  790.                     return 1;
  791.                 }
  792.         }
  793.     }
  794.     
  795.     if(isMPEG){
  796.         if( data[read_state.in_ptr]==0xFF && header_pos==0){
  797.             // MPEG audio header 0xFFF-
  798.             read_state.header_in_course = true;
  799.             header_pos = 1;
  800.             //Handle presentation info
  801.             if(    (read_state.PES.pInfo.PTS != 0) 
  802.                 && (headers_found==0)  ){
  803.                     read_state.frame_pInfo.hasPTS = true;
  804.                     read_state.frame_pInfo.PTS    
  805.                     = read_state.PES.pInfo.PTS;
  806.                 }
  807.                 else{
  808.                     read_state.frame_pInfo.hasPTS = false;
  809.                     read_state.frame_pInfo.PTS    = 0;
  810.             }
  811.             mpeg_header[0] = data[read_state.in_ptr];
  812.             return 0;
  813.         }
  814.         if( (data[read_state.in_ptr]&0xF8)==0xF8 && header_pos==1){
  815.             // MPEG audio header
  816.  
  817.             mpeg_layer = (data[read_state.in_ptr]&0x06)>>1;
  818.             if( mpeg_layer==3 ) //If the frame is Layer I
  819.                 mpeg_layer=1;
  820.             else
  821.                 if( mpeg_layer==1 ) //If the frame is Layer III
  822.                     mpeg_layer=3;
  823.             if( !mpeg_layer )
  824.                 header_pos = 0;
  825.             else
  826.                 header_pos = 2;
  827.  
  828.             mpeg_header[1] = data[read_state.in_ptr];
  829.  
  830.             read_state.header_in_course = true;
  831.             header_pos = 2;
  832.             return 0;
  833.         }
  834.         if( header_pos==2 ){
  835.             read_state.header_in_course = true;
  836.  
  837.             bit_rate_index = (data[read_state.in_ptr]&0xF0)>>4;
  838.             if( bit_rate_index == 16  ||  bit_rate_index == 0 ){
  839.                 header_pos = 0;
  840.                 return 0;
  841.             }
  842.             bitrate            = mpeg1_bitrate_table[mpeg_layer-1][bit_rate_index]*1000;
  843.             sampling_frequency = (data[read_state.in_ptr]&0x0C)>>2;
  844.             if( sampling_frequency == 3 ){
  845.                 header_pos = 0;
  846.                 return 0;
  847.             }
  848.             padding_bit        = (data[read_state.in_ptr]&0x02)>>1;
  849.             //Find number of slots and frame size
  850.             if(mpeg_layer == 1){
  851.                 N = floor( (12 *(double)bitrate)/(double)mpeg1_sampling_frequency[sampling_frequency] );
  852.                 N = padding_bit ? (N+1) : N;
  853.                 read_state.frame_size = N*4;
  854.             }
  855.             else
  856.             {
  857.                 N = floor( (144*(double)bitrate)/(double)mpeg1_sampling_frequency[sampling_frequency] );
  858.                 N = padding_bit ? (N+1) : N;
  859.                 read_state.frame_size = N;
  860.             }
  861.             
  862.             mpeg_header[2] = data[read_state.in_ptr];
  863.             memcpy( read_state.frame_data, mpeg_header, 3);
  864.  
  865.             read_state.frame_remaining_bytes = read_state.frame_size - 3;
  866.             read_state.out_ptr               = 3;
  867.             header_pos = 0;
  868.             return 1;
  869.         }
  870.     }
  871.     header_pos = 0;
  872.     read_state.header_in_course = false;
  873.     return 0;
  874. }
  875.  
  876. int Audio::FindHeader(ui32 headers_found)
  877. {
  878.     bool header_found = false;
  879.  
  880.  
  881.     //Search for an audio header from the current position
  882.     while( read_state.in_ptr < read_state.PES.pInfo.payloadSize ){
  883.         header_found = ParseHeader(headers_found);
  884.         read_state.in_ptr++;
  885.         if(header_found)
  886.                 break;
  887.     }
  888.  
  889.     return header_found;
  890.  
  891. }
  892. int Audio::ReadSpanInit()
  893. {
  894.  
  895.     //Force first time
  896.     read_state.frame_in_course       = false;
  897.     read_state.header_in_course      = false;
  898.     read_state.frame_size            = 0;
  899.     read_state.frame_remaining_bytes = 0;
  900.     read_state.lastSCR = 0;
  901.     read_state.delta = 0;    
  902.     header_pos = 0;
  903.     ReadLPES((unsigned char **)&read_state.PES.data, &read_state.PES.pInfo);
  904.  
  905.     return 1;
  906. }
  907.  
  908. int Audio::decodeFrame(CAudioFrame *frame, short *pcm_samples)
  909. {    
  910.     if(isAC3){
  911.         if(AC3Dec)
  912.             AC3Dec->decodeFrame((short *)frame->data, frame->datasize,pcm_samples);
  913.         return 1536;
  914.     }
  915.     if(isMPEG){
  916.         if(isMPEG)
  917.             MPEGDec->decodeFrame( (ui8 *)pcm_samples, frame->data, frame->datasize );
  918.         return 1152;
  919.     }
  920.     return 0;
  921. }
  922.